package com.liuqing.www.多线程技术;

import java.util.concurrent.*;

/**--------------------- 继承thread(Thread本身实现Runnable)--------------------------------*/
public class ThreadTest {
	
	/**守护进程（Daemon）是运行在后台的一种特殊进程。它独立于控制终端并且周期性地执行某种任务或等待处理某些发生的事件（最根本的）。
	 * 每个线程都有一个优先级，高优先级线程的执行优先于低优先级线程。
	 * 每个线程都可以或不可以标记为一个守护程序。
	 * 当某个线程中运行的代码创建一个新 Thread 对象时，该新线程的初始优先级被设定为创建线程的优先级，
	 * 并且当且仅当创建线程是守护线程时，新线程才是守护程序。 
	 * 后台线程==守护线程、用户线程：区别只有后台线程时，程序会退出main结束则结束，，二若存在用户线程则据需，setDameon\isDaemon来切换
	 * @param args
	 */
	public static void main(String[] args) {
//		MyThread thread1=new MyThread("thread1");
//		MyThread thread2=new MyThread("thread2");
//		thread1.start();
//		thread2.start();
//---------------------------------------------------------
//		Student s1=new Student("lili");
//		new Thread(new TestMitiThread1(s1,1)).start();//同步student被锁定
//		//Student s2=new Student("liuqing");
//		new Thread(new TestMitiThread1(s1,2)).start();
		//---------------------------------------------------------
		ExecutorService threadpool=Executors.newFixedThreadPool(2);//始终只有2个线程在运行
		for(int i=0;i<100;i++){
			MyThread t=new MyThread(i+"");
			threadpool.execute(t);
		}
	}
}
	class MyThread extends Thread{
		public MyThread(String name){
//			setName(name);
			super(name);
		}
		public void run(){//重新run方法
			
			while(true){
			 System.out.println(getName() + " 线程运行开始!");
			 try {
				Thread.sleep(2000);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
//				e.printStackTrace();
			}
			}
		}
	}
	/**--------------------- 实现Runnable接口--------------------------------*/
	class TestMitiThread1 implements Runnable {
		private Student stu;
		int i;
		public TestMitiThread1(Student s,int i){
			stu=s;
			this.i=i;
		}
		@Override
		public void run() {//实现run方法
			while(true){
				stu.readBook();
				System.out.print("----线程"+i);
				System.out.println();
				try {
					
				} catch (Exception e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}
		
	}
	class Student{
		String name;
		Student(String name){
			this.name=name;
		}
		public  synchronized void readBook(){
			System.out.print(name+"在读书");
			Thread.yield();
		}
	}
/*方法摘要 
static Thread currentThread() 
          返回对当前正在执行的线程对象的引用。 
 ClassLoader getContextClassLoader() 
          返回该线程的上下文 ClassLoader。 
 long getId() 
          返回该线程的标识符。 
 String getName() 
          返回该线程的名称。 
 int getPriority() 
          返回线程的优先级。 
 Thread.State getState() 
          返回该线程的状态。 
 ThreadGroup getThreadGroup() 
          返回该线程所属的线程组。 
static boolean holdsLock(Object obj) 
          当且仅当当前线程在指定的对象上保持监视器锁时，才返回 true。 
 void interrupt() 
          中断线程。 
static boolean interrupted() 
          测试当前线程是否已经中断。 
 boolean isAlive() 
          测试线程是否处于活动状态。 
 boolean isDaemon() 
          测试该线程是否为守护线程。 
 boolean isInterrupted() 
          测试线程是否已经中断。 
 void join() 
          等待该线程终止。 
 void join(long millis) 
          等待该线程终止的时间最长为 millis 毫秒。 
 void join(long millis, int nanos) 
          等待该线程终止的时间最长为 millis 毫秒 + nanos 纳秒。 
 void resume() 
          已过时。 该方法只与 suspend() 一起使用，但 suspend() 已经遭到反对，因为它具有死锁倾向。有关更多信息，请参阅为何 Thread.stop、Thread.suspend 和 Thread.resume 遭到反对？。 
 void run() 
          如果该线程是使用独立的 Runnable 运行对象构造的，则调用该 Runnable 对象的 run 方法；否则，该方法不执行任何操作并返回。 
 void setContextClassLoader(ClassLoader cl) 
          设置该线程的上下文 ClassLoader。 
 void setDaemon(boolean on) 
          将该线程标记为守护线程或用户线程。 
static void setDefaultUncaughtExceptionHandler(Thread.UncaughtExceptionHandler eh) 
          设置当线程由于未捕获到异常而突然终止，并且没有为该线程定义其他处理程序时所调用的默认处理程序。 
 void setName(String name) 
          改变线程名称，使之与参数 name 相同。 
 void setPriority(int newPriority) 
          更改线程的优先级。 
 void setUncaughtExceptionHandler(Thread.UncaughtExceptionHandler eh) 
          设置该线程由于未捕获到异常而突然终止时调用的处理程序。 
static void sleep(long millis) 
          在指定的毫秒数内让当前正在执行的线程休眠（暂停执行）。 
static void sleep(long millis, int nanos) 
          在指定的毫秒数加指定的纳秒数内让当前正在执行的线程休眠（暂停执行）。 
 void start() 
          使该线程开始执行；Java 虚拟机调用该线程的 run 方法。 
 void stop() 
          已过时。 该方法具有固有的不安全性。用 Thread.stop 来终止线程将释放它已经锁定的所有监视器（作为沿堆栈向上传播的未检查 ThreadDeath 异常的一个自然后果）。如果以前受这些监视器保护的任何对象都处于一种不一致的状态，则损坏的对象将对其他线程可见，这有可能导致任意的行为。stop 的许多使用都应由只修改某些变量以指示目标线程应该停止运行的代码来取代。目标线程应定期检查该变量，并且如果该变量指示它要停止运行，则从其运行方法依次返回。如果目标线程等待很长时间（例如基于一个条件变量），则应使用 interrupt 方法来中断该等待。有关更多信息，请参阅《为何不赞成使用 Thread.stop、Thread.suspend 和 Thread.resume？》。 
 void stop(Throwable obj) 
          已过时。 该方法具有固有的不安全性。请参阅 stop() 以获得详细信息。该方法的附加危险是它可用于生成目标线程未准备处理的异常（包括若没有该方法该线程不太可能抛出的已检查的异常）。有关更多信息，请参阅为何 Thread.stop、Thread.suspend 和 Thread.resume 遭到反对？。 
 void suspend() 
          已过时。 该方法已经遭到反对，因为它具有固有的死锁倾向。如果目标线程挂起时在保护关键系统资源的监视器上保持有锁，则在目标线程重新开始以前任何线程都不能访问该资源。如果重新开始目标线程的线程想在调用 resume 之前锁定该监视器，则会发生死锁。这类死锁通常会证明自己是“冻结”的进程。有关更多信息，请参阅为何 Thread.stop、Thread.suspend 和 Thread.resume 遭到反对？。 
 String toString() 
          返回该线程的字符串表示形式，包括线程名称、优先级和线程组。 
static void yield() 
          暂停当前正在执行的线程对象，并执行其他线程。
           						
 	  start()					获取cpu       run结束或者异常
 new---------->runable(可运行状态)<----->running-----------》dead
 								yield
 		wait	   notify		同步锁解除
 running------>等待-------》锁定------===》runable(可运行状态)					
				  interrupt
		sleep、join	  	sleep结束、join中断、io完成
 running----------->中断---------------------===》runable(可运行状态)		
        synchronized（同步）
 running--------------》锁定	
	*
	*  <---等待态同步《-|		
	*  |notify		 |wait
	*  |   获得资源    |       sleep
	*就绪《------》运行状态<----->睡眠态
	*  ||	中断yield		 时间倒
	*  ||
	*  ||资源短缺
	*  ||------》阻塞态
	*  |		 |资源就绪
	*  |《-------|
	*/		
	class ThreadPOOL{
		
	}